home *** CD-ROM | disk | FTP | other *** search
/ Champak 138 / Volume 138 Aug 19 2011 - Damaged.iso / Games / super_racer.swf / scripts / DefineSprite_270_trackEnd / frame_41 / DoAction.as
Text File  |  2011-08-19  |  62KB  |  1,069 lines

  1. function ┬º\x01\x02┬º()
  2. {
  3.    return 1982 % 511 * 5;
  4. }
  5. var ┬º\x01┬º = -2078 + "\x01\x02"();
  6. loop0:
  7. while(true)
  8. {
  9.    if(eval("\x01") == 167)
  10.    {
  11.       set("\x01",eval("\x01") + 693);
  12.       ┬º┬ºpush(true);
  13.       continue;
  14.    }
  15.    if(eval("\x01") != 544)
  16.    {
  17.       if(eval("\x01") == 496)
  18.       {
  19.          set("\x01",eval("\x01") + 123);
  20.       }
  21.       else if(eval("\x01") == 289)
  22.       {
  23.          set("\x01",eval("\x01") + 623);
  24.          if(function ┬º\x01\x02┬º()
  25.          {
  26.             return 1982 % 511 * 5;
  27.          })
  28.          {
  29.             set("\x01",eval("\x01") + 0);
  30.          }
  31.       }
  32.       else if(eval("\x01") == 665)
  33.       {
  34.          set("\x01",eval("\x01") - 331);
  35.       }
  36.       else if(eval("\x01") == 513)
  37.       {
  38.          set("\x01",eval("\x01") + 42);
  39.       }
  40.       else if(eval("\x01") == 863)
  41.       {
  42.          set("\x01",eval("\x01") - 244);
  43.       }
  44.       else if(eval("\x01") == 619)
  45.       {
  46.          set("\x01",eval("\x01") + 322);
  47.          ┬º┬ºpush(true);
  48.       }
  49.       else
  50.       {
  51.          if(eval("\x01") == 912)
  52.          {
  53.             set("\x01",eval("\x01") - 895);
  54.             hornsplaying = false;
  55.             break;
  56.          }
  57.          if(eval("\x01") == 555)
  58.          {
  59.             set("\x01",eval("\x01") + 245);
  60.             ┬º┬ºpush("\x0f");
  61.             ┬º┬ºpush(1);
  62.          }
  63.          else if(eval("\x01") == 941)
  64.          {
  65.             set("\x01",eval("\x01") - 677);
  66.             if(function ┬º\x01\x02┬º()
  67.             {
  68.                return 1982 % 511 * 5;
  69.             })
  70.             {
  71.                set("\x01",eval("\x01") + 401);
  72.             }
  73.          }
  74.          else if(eval("\x01") == 860)
  75.          {
  76.             set("\x01",eval("\x01") - 367);
  77.             if(function ┬º\x01\x02┬º()
  78.             {
  79.                return 1982 % 511 * 5;
  80.             })
  81.             {
  82.                set("\x01",eval("\x01") + 3);
  83.             }
  84.          }
  85.          else if(eval("\x01") == 666)
  86.          {
  87.             set("\x01",eval("\x01") - 549);
  88.             ┬º┬ºpush(eval(function ┬º\x01\x02┬º()
  89.             {
  90.                return 1982 % 511 * 5;
  91.             }));
  92.          }
  93.          else if(eval("\x01") == 334)
  94.          {
  95.             set("\x01",eval("\x01") + 397);
  96.             ┬º┬ºpush(true);
  97.          }
  98.          else if(eval("\x01") == 304)
  99.          {
  100.             set("\x01",eval("\x01") + 251);
  101.          }
  102.          else if(eval("\x01") == 117)
  103.          {
  104.             set("\x01",eval("\x01") + 172);
  105.             ┬º┬ºpush(!function ┬º\x01\x02┬º()
  106.             {
  107.                return 1982 % 511 * 5;
  108.             });
  109.          }
  110.          else if(eval("\x01") == 54)
  111.          {
  112.             set("\x01",eval("\x01") + 280);
  113.          }
  114.          else if(eval("\x01") == 731)
  115.          {
  116.             set("\x01",eval("\x01") - 187);
  117.             if(function ┬º\x01\x02┬º()
  118.             {
  119.                return 1982 % 511 * 5;
  120.             })
  121.             {
  122.                set("\x01",eval("\x01") - 240);
  123.             }
  124.          }
  125.          else
  126.          {
  127.             if(eval("\x01") == 493)
  128.             {
  129.                set("\x01",eval("\x01") + 3);
  130.                break;
  131.             }
  132.             if(eval("\x01") == 264)
  133.             {
  134.                set("\x01",eval("\x01") + 401);
  135.                ┬º┬ºpush(┬º┬ºpop() == function ┬º\x01\x02┬º()
  136.                {
  137.                   return 1982 % 511 * 5;
  138.                });
  139.                break;
  140.             }
  141.             if(eval("\x01") == 800)
  142.             {
  143.                set("\x01",eval("\x01") - 140);
  144.                var ┬º┬ºpop() = function ┬º\x01\x02┬º()
  145.                {
  146.                   return 1982 % 511 * 5;
  147.                };
  148.             }
  149.             else
  150.             {
  151.                if(eval("\x01") != 660)
  152.                {
  153.                   if(eval("\x01") == 17)
  154.                   {
  155.                      set("\x01",eval("\x01") - 17);
  156.                      break;
  157.                   }
  158.                   break;
  159.                }
  160.                set("\x01",eval("\x01") + 6);
  161.                ┬º┬ºpush("\x0f");
  162.             }
  163.          }
  164.       }
  165.       continue;
  166.    }
  167.    set("\x01",eval("\x01") - 240);
  168.    while(true)
  169.    {
  170.       if(┬º┬ºpop() == function ┬º\x01\x02┬º()
  171.       {
  172.          return 1982 % 511 * 5;
  173.       })
  174.       {
  175.          set("\x01",eval("\x01") + 110);
  176.       }
  177.       else if(eval("\x01") == 703)
  178.       {
  179.          set("\x01",eval("\x01") + 230);
  180.       }
  181.       else if(eval("\x01") == 309)
  182.       {
  183.          set("\x01",eval("\x01") - 2);
  184.       }
  185.       else if(eval("\x01") == 307)
  186.       {
  187.          set("\x01",eval("\x01") + 209);
  188.          ┬º┬ºpush(true);
  189.       }
  190.       else if(eval("\x01") == 766)
  191.       {
  192.          set("\x01",eval("\x01") + 77);
  193.          ┬º┬ºpush(eval(┬º┬ºpop()));
  194.       }
  195.       else if(eval("\x01") == 516)
  196.       {
  197.          set("\x01",eval("\x01") - 461);
  198.          if(┬º┬ºpop())
  199.          {
  200.             set("\x01",eval("\x01") + 357);
  201.          }
  202.       }
  203.       else
  204.       {
  205.          if(eval("\x01") == 980)
  206.          {
  207.             set("\x01",eval("\x01") - 651);
  208.             eval("∩┐╜∩┐╜i\x06")["\x18∩┐╜∩┐╜i∩┐╜"]();
  209.             eval("∩┐╜∩┐╜i\x06")[┬º┬ºconstant(3)]("∩┐╜B\r∩┐╜∩┐╜");
  210.             eval("∩┐╜∩┐╜i\x06")[┬º┬ºconstant(4)] = "∩┐╜B\r∩┐╜∩┐╜";
  211.             eval("∩┐╜∩┐╜i\x06")[┬º┬ºconstant(5)] = 1;
  212.             eval("∩┐╜∩┐╜i\x06")[┬º┬ºconstant(6)][┬º┬ºconstant(7)](0,100);
  213.             break loop0;
  214.          }
  215.          if(eval("\x01") == 422)
  216.          {
  217.             set("\x01",eval("\x01") - 318);
  218.             var ┬º┬ºpop() = ┬º┬ºpop();
  219.          }
  220.          else if(eval("\x01") == 412)
  221.          {
  222.             set("\x01",eval("\x01") + 521);
  223.          }
  224.          else if(eval("\x01") == 328)
  225.          {
  226.             set("\x01",eval("\x01") + 652);
  227.          }
  228.          else
  229.          {
  230.             if(eval("\x01") != 926)
  231.             {
  232.                if(eval("\x01") == 329)
  233.                {
  234.                   set("\x01",eval("\x01") - 329);
  235.                   break loop0;
  236.                }
  237.                break loop0;
  238.             }
  239.             set("\x01",eval("\x01") - 598);
  240.             if(┬º┬ºpop())
  241.             {
  242.                set("\x01",eval("\x01") + 652);
  243.             }
  244.          }
  245.       }
  246.       while(true)
  247.       {
  248.          if(eval("\x01") == 153)
  249.          {
  250.             set("\x01",eval("\x01") + 194);
  251.             ┬º┬ºpush(true);
  252.          }
  253.          else
  254.          {
  255.             if(eval("\x01") == 55)
  256.             {
  257.                set("\x01",eval("\x01") + 357);
  258.                loop5:
  259.                while(true)
  260.                {
  261.                   set(┬º┬ºpop(),┬º┬ºpop() - 312);
  262.                   while(true)
  263.                   {
  264.                      if(eval("\x01") == 397)
  265.                      {
  266.                         set("\x01",eval("\x01") + 139);
  267.                         ┬º┬ºpush(true);
  268.                      }
  269.                      else if(eval("\x01") == 900)
  270.                      {
  271.                         set("\x01",eval("\x01") - 48);
  272.                         ┬º┬ºpush(eval(┬º┬ºpop()));
  273.                      }
  274.                      else if(eval("\x01") == 852)
  275.                      {
  276.                         set("\x01",eval("\x01") + 36);
  277.                         ┬º┬ºpush(!┬º┬ºpop());
  278.                      }
  279.                      else if(eval("\x01") == 238)
  280.                      {
  281.                         set("\x01",eval("\x01") + 410);
  282.                      }
  283.                      else if(eval("\x01") == 363)
  284.                      {
  285.                         set("\x01",eval("\x01") - 252);
  286.                      }
  287.                      else if(eval("\x01") == 507)
  288.                      {
  289.                         set("\x01",eval("\x01") + 289);
  290.                         ┬º┬ºpush(true);
  291.                      }
  292.                      else
  293.                      {
  294.                         if(eval("\x01") == 113)
  295.                         {
  296.                            break loop5;
  297.                         }
  298.                         if(eval("\x01") == 153)
  299.                         {
  300.                            set("\x01",eval("\x01") + 495);
  301.                         }
  302.                         else
  303.                         {
  304.                            if(eval("\x01") == 111)
  305.                            {
  306.                               set("\x01",eval("\x01") + 139);
  307.                               if(eval(">∩┐╜")["@∩┐╜∩┐╜1"] != "Ix∩┐╜s")
  308.                               {
  309.                                  eval(">∩┐╜")["∩┐╜\x15;"]();
  310.                                  eval(">∩┐╜")[┬º┬ºconstant(4)]("Ix∩┐╜s");
  311.                                  eval(">∩┐╜")["@∩┐╜∩┐╜1"] = "Ix∩┐╜s";
  312.                                  eval(">∩┐╜")[┬º┬ºconstant(5)] = 1;
  313.                               }
  314.                               break loop0;
  315.                            }
  316.                            if(eval("\x01") == 762)
  317.                            {
  318.                               set("\x01",eval("\x01") - 255);
  319.                            }
  320.                            else if(eval("\x01") == 648)
  321.                            {
  322.                               set("\x01",eval("\x01") + 22);
  323.                               ┬º┬ºpush(true);
  324.                            }
  325.                            else
  326.                            {
  327.                               if(eval("\x01") == 974)
  328.                               {
  329.                                  set("\x01",eval("\x01") - 736);
  330.                                  stop();
  331.                                  break loop0;
  332.                               }
  333.                               if(eval("\x01") == 558)
  334.                               {
  335.                                  set("\x01",eval("\x01") + 206);
  336.                                  break loop0;
  337.                               }
  338.                               if(eval("\x01") == 670)
  339.                               {
  340.                                  set("\x01",eval("\x01") - 216);
  341.                                  if(┬º┬ºpop())
  342.                                  {
  343.                                     set("\x01",eval("\x01") + 248);
  344.                                  }
  345.                               }
  346.                               else
  347.                               {
  348.                                  if(eval("\x01") == 819)
  349.                                  {
  350.                                     break;
  351.                                  }
  352.                                  if(eval("\x01") == 100)
  353.                                  {
  354.                                     set("\x01",eval("\x01") + 800);
  355.                                     ┬º┬ºpush("\x0f");
  356.                                  }
  357.                                  else if(eval("\x01") == 536)
  358.                                  {
  359.                                     set("\x01",eval("\x01") - 423);
  360.                                     if(┬º┬ºpop())
  361.                                     {
  362.                                        set("\x01",eval("\x01") + 649);
  363.                                     }
  364.                                  }
  365.                                  else if(eval("\x01") == 796)
  366.                                  {
  367.                                     set("\x01",eval("\x01") + 178);
  368.                                     if(┬º┬ºpop())
  369.                                     {
  370.                                        set("\x01",eval("\x01") - 736);
  371.                                     }
  372.                                  }
  373.                                  else if(eval("\x01") == 764)
  374.                                  {
  375.                                     set("\x01",eval("\x01") + 123);
  376.                                  }
  377.                                  else
  378.                                  {
  379.                                     if(eval("\x01") == 454)
  380.                                     {
  381.                                        set("\x01",eval("\x01") + 248);
  382.                                        break loop0;
  383.                                     }
  384.                                     if(eval("\x01") == 702)
  385.                                     {
  386.                                        set("\x01",eval("\x01") - 696);
  387.                                     }
  388.                                     else if(eval("\x01") == 684)
  389.                                     {
  390.                                        set("\x01",eval("\x01") - 678);
  391.                                     }
  392.                                     else if(eval("\x01") == 6)
  393.                                     {
  394.                                        set("\x01",eval("\x01") + 418);
  395.                                        ┬º┬ºpush(true);
  396.                                     }
  397.                                     else if(eval("\x01") == 424)
  398.                                     {
  399.                                        set("\x01",eval("\x01") + 134);
  400.                                        if(┬º┬ºpop())
  401.                                        {
  402.                                           set("\x01",eval("\x01") + 206);
  403.                                        }
  404.                                     }
  405.                                     else if(eval("\x01") == 888)
  406.                                     {
  407.                                        set("\x01",eval("\x01") - 525);
  408.                                        if(┬º┬ºpop())
  409.                                        {
  410.                                           set("\x01",eval("\x01") - 252);
  411.                                        }
  412.                                     }
  413.                                     else
  414.                                     {
  415.                                        if(eval("\x01") == 250)
  416.                                        {
  417.                                           set("\x01",eval("\x01") - 250);
  418.                                           break loop0;
  419.                                        }
  420.                                        if(eval("\x01") == 232)
  421.                                        {
  422.                                           set("\x01",eval("\x01") + 655);
  423.                                        }
  424.                                        else if(eval("\x01") == 887)
  425.                                        {
  426.                                           set("\x01",eval("\x01") - 272);
  427.                                           ┬º┬ºpush("\x0f");
  428.                                           ┬º┬ºpush(1);
  429.                                        }
  430.                                        else
  431.                                        {
  432.                                           if(eval("\x01") != 615)
  433.                                           {
  434.                                              break loop0;
  435.                                           }
  436.                                           set("\x01",eval("\x01") - 515);
  437.                                           var ┬º┬ºpop() = ┬º┬ºpop();
  438.                                        }
  439.                                     }
  440.                                  }
  441.                               }
  442.                            }
  443.                         }
  444.                      }
  445.                   }
  446.                }
  447.                set("\x01",eval("\x01") + 649);
  448.                loop7:
  449.                while(true)
  450.                {
  451.                   while(true)
  452.                   {
  453.                      if(eval("\x01") != 991)
  454.                      {
  455.                         if(eval("\x01") != 657)
  456.                         {
  457.                            if(eval("\x01") != 86)
  458.                            {
  459.                               if(eval("\x01") != 337)
  460.                               {
  461.                                  if(eval("\x01") != 663)
  462.                                  {
  463.                                     if(eval("\x01") != 314)
  464.                                     {
  465.                                        if(eval("\x01") != 405)
  466.                                        {
  467.                                           if(eval("\x01") != 892)
  468.                                           {
  469.                                              if(eval("\x01") == 977)
  470.                                              {
  471.                                                 break loop7;
  472.                                              }
  473.                                              if(eval("\x01") != 670)
  474.                                              {
  475.                                                 if(eval("\x01") != 562)
  476.                                                 {
  477.                                                    if(eval("\x01") != 201)
  478.                                                    {
  479.                                                       if(eval("\x01") != 220)
  480.                                                       {
  481.                                                          if(eval("\x01") == 808)
  482.                                                          {
  483.                                                             set("\x01",eval("\x01") - 151);
  484.                                                             break loop0;
  485.                                                          }
  486.                                                          if(eval("\x01") == 599)
  487.                                                          {
  488.                                                             set("\x01",eval("\x01") + 209);
  489.                                                             if(┬º┬ºpop())
  490.                                                             {
  491.                                                                set("\x01",eval("\x01") - 151);
  492.                                                             }
  493.                                                             continue;
  494.                                                          }
  495.                                                          if(eval("\x01") == 109)
  496.                                                          {
  497.                                                             set("\x01",eval("\x01") + 446);
  498.                                                             continue;
  499.                                                             continue;
  500.                                                          }
  501.                                                          if(eval("\x01") == 929)
  502.                                                          {
  503.                                                             set("\x01",eval("\x01") - 615);
  504.                                                             continue;
  505.                                                             continue;
  506.                                                          }
  507.                                                          if(eval("\x01") == 555)
  508.                                                          {
  509.                                                             set("\x01",eval("\x01") + 115);
  510.                                                             ┬º┬ºpush(true);
  511.                                                             continue;
  512.                                                          }
  513.                                                          if(eval("\x01") == 330)
  514.                                                          {
  515.                                                             set("\x01",eval("\x01") + 390);
  516.                                                             ┬º┬ºpush(true);
  517.                                                             continue;
  518.                                                          }
  519.                                                          if(eval("\x01") == 720)
  520.                                                          {
  521.                                                             set("\x01",eval("\x01") + 257);
  522.                                                             if(┬º┬ºpop())
  523.                                                             {
  524.                                                                set("\x01",eval("\x01") - 640);
  525.                                                             }
  526.                                                             continue;
  527.                                                          }
  528.                                                       }
  529.                                                       set("\x01",eval("\x01") + 551);
  530.                                                       continue;
  531.                                                       if(eval("\x01") == 645)
  532.                                                       {
  533.                                                          set("\x01",eval("\x01") + 111);
  534.                                                          break loop0;
  535.                                                       }
  536.                                                       if(eval("\x01") == 140)
  537.                                                       {
  538.                                                          set("\x01",eval("\x01") + 504);
  539.                                                          if(┬º┬ºpop())
  540.                                                          {
  541.                                                             set("\x01",eval("\x01") - 82);
  542.                                                          }
  543.                                                          continue;
  544.                                                       }
  545.                                                    }
  546.                                                    set("\x01",eval("\x01") + 462);
  547.                                                    ┬º┬ºpush(eval(┬º┬ºpop()));
  548.                                                    continue;
  549.                                                    if(eval("\x01") != 756)
  550.                                                    {
  551.                                                       if(eval("\x01") == 644)
  552.                                                       {
  553.                                                          set("\x01",eval("\x01") - 82);
  554.                                                          loop9:
  555.                                                          while(true)
  556.                                                          {
  557.                                                             set(┬º┬ºpop(),eval(┬º┬ºpop()) - 207);
  558.                                                             while(true)
  559.                                                             {
  560.                                                                if(eval("\x01") != 664)
  561.                                                                {
  562.                                                                   if(eval("\x01") != 457)
  563.                                                                   {
  564.                                                                      if(eval("\x01") != 35)
  565.                                                                      {
  566.                                                                         if(eval("\x01") != 266)
  567.                                                                         {
  568.                                                                            if(eval("\x01") != 330)
  569.                                                                            {
  570.                                                                               if(eval("\x01") == 834)
  571.                                                                               {
  572.                                                                                  break loop9;
  573.                                                                               }
  574.                                                                               if(eval("\x01") == 161)
  575.                                                                               {
  576.                                                                                  set("\x01",eval("\x01") + 169);
  577.                                                                                  ┬º┬ºpush("\x0f");
  578.                                                                                  ┬º┬ºpush(1);
  579.                                                                                  continue;
  580.                                                                               }
  581.                                                                               if(eval("\x01") == 302)
  582.                                                                               {
  583.                                                                                  set("\x01",eval("\x01") + 532);
  584.                                                                                  if(┬º┬ºpop())
  585.                                                                                  {
  586.                                                                                     set("\x01",eval("\x01") - 306);
  587.                                                                                  }
  588.                                                                                  continue;
  589.                                                                               }
  590.                                                                               if(eval("\x01") == 736)
  591.                                                                               {
  592.                                                                                  set("\x01",eval("\x01") - 279);
  593.                                                                                  ┬º┬ºpush(!┬º┬ºpop());
  594.                                                                                  continue;
  595.                                                                               }
  596.                                                                               if(eval("\x01") == 184)
  597.                                                                               {
  598.                                                                                  set("\x01",eval("\x01") + 82);
  599.                                                                                  ┬º┬ºpush(true);
  600.                                                                                  continue;
  601.                                                                               }
  602.                                                                               if(eval("\x01") == 26)
  603.                                                                               {
  604.                                                                                  set("\x01",eval("\x01") + 158);
  605.                                                                                  continue;
  606.                                                                                  continue loop9;
  607.                                                                               }
  608.                                                                               if(eval("\x01") == 370)
  609.                                                                               {
  610.                                                                                  set("\x01",eval("\x01") - 209);
  611.                                                                                  continue;
  612.                                                                               }
  613.                                                                            }
  614.                                                                            set("\x01",eval("\x01") - 295);
  615.                                                                            var ┬º┬ºpop() = ┬º┬ºpop();
  616.                                                                            continue;
  617.                                                                            if(eval("\x01") != 48)
  618.                                                                            {
  619.                                                                               if(eval("\x01") == 88)
  620.                                                                               {
  621.                                                                                  set("\x01",eval("\x01") + 216);
  622.                                                                                  addr1253:
  623.                                                                                  if(!┬º┬ºpop())
  624.                                                                                  {
  625.                                                                                     set("\x01",eval("\x01") - 517);
  626.                                                                                     addr1081:
  627.                                                                                     if(eval("\x01") == 505)
  628.                                                                                     {
  629.                                                                                        set("\x01",eval("\x01") - 298);
  630.                                                                                        ┬º┬ºgoto(addr1081);
  631.                                                                                        ┬º┬ºpush(true);
  632.                                                                                     }
  633.                                                                                     if(eval("\x01") != 231)
  634.                                                                                     {
  635.                                                                                        if(eval("\x01") == 295)
  636.                                                                                        {
  637.                                                                                           set("\x01",eval("\x01") + 684);
  638.                                                                                           ┬º┬ºgoto(addr1081);
  639.                                                                                           ┬º┬ºpush(true);
  640.                                                                                        }
  641.                                                                                        if(eval("\x01") == 451)
  642.                                                                                        {
  643.                                                                                           set("\x01",eval("\x01") + 317);
  644.                                                                                           ┬º┬ºgoto(addr1081);
  645.                                                                                           ┬º┬ºpush(eval(┬º┬ºpop()));
  646.                                                                                        }
  647.                                                                                        if(eval("\x01") == 207)
  648.                                                                                        {
  649.                                                                                           set("\x01",eval("\x01") + 24);
  650.                                                                                           if(!┬º┬ºpop())
  651.                                                                                           {
  652.                                                                                              addr1159:
  653.                                                                                              ┬º┬ºgoto(addr1081);
  654.                                                                                           }
  655.                                                                                           set("\x01",eval("\x01") + 503);
  656.                                                                                           ┬º┬ºgoto(addr1159);
  657.                                                                                        }
  658.                                                                                        if(eval("\x01") != 219)
  659.                                                                                        {
  660.                                                                                           if(eval("\x01") == 979)
  661.                                                                                           {
  662.                                                                                              set("\x01",eval("\x01") - 760);
  663.                                                                                              if(!┬º┬ºpop())
  664.                                                                                              {
  665.                                                                                                 addr1193:
  666.                                                                                                 ┬º┬ºgoto(addr1081);
  667.                                                                                              }
  668.                                                                                              set("\x01",eval("\x01") + 439);
  669.                                                                                              ┬º┬ºgoto(addr1193);
  670.                                                                                           }
  671.                                                                                           if(eval("\x01") == 600)
  672.                                                                                           {
  673.                                                                                              set("\x01",eval("\x01") - 149);
  674.                                                                                              ┬º┬ºgoto(addr1081);
  675.                                                                                              ┬º┬ºpush("\x0f");
  676.                                                                                           }
  677.                                                                                           if(eval("\x01") == 488)
  678.                                                                                           {
  679.                                                                                              set("\x01",eval("\x01") - 193);
  680.                                                                                              ┬º┬ºgoto(addr1081);
  681.                                                                                           }
  682.                                                                                           if(eval("\x01") == 734)
  683.                                                                                           {
  684.                                                                                              set("\x01",eval("\x01") - 439);
  685.                                                                                              ┬º┬ºgoto(addr1081);
  686.                                                                                           }
  687.                                                                                           if(eval("\x01") == 481)
  688.                                                                                           {
  689.                                                                                              set("\x01",eval("\x01") + 273);
  690.                                                                                              ┬º┬ºgoto(addr1081);
  691.                                                                                           }
  692.                                                                                           ┬º┬ºgoto(addr1253);
  693.                                                                                           ┬º┬ºpush(eval("\x01") != 658);
  694.                                                                                        }
  695.                                                                                        set("\x01",eval("\x01") + 439);
  696.                                                                                        break loop0;
  697.                                                                                     }
  698.                                                                                     set("\x01",eval("\x01") + 503);
  699.                                                                                     break loop0;
  700.                                                                                  }
  701.                                                                                  if(eval("\x01") == 575)
  702.                                                                                  {
  703.                                                                                     set("\x01",eval("\x01") + 37);
  704.                                                                                     if(!┬º┬ºpop())
  705.                                                                                     {
  706.                                                                                        addr1281:
  707.                                                                                        ┬º┬ºgoto(addr1081);
  708.                                                                                     }
  709.                                                                                     set("\x01",eval("\x01") + 0);
  710.                                                                                     ┬º┬ºgoto(addr1281);
  711.                                                                                  }
  712.                                                                                  if(eval("\x01") != 237)
  713.                                                                                  {
  714.                                                                                     if(eval("\x01") == 141)
  715.                                                                                     {
  716.                                                                                        set("\x01",eval("\x01") + 670);
  717.                                                                                        ┬º┬ºgoto(addr1081);
  718.                                                                                        ┬º┬ºpush(true);
  719.                                                                                     }
  720.                                                                                     if(eval("\x01") == 754)
  721.                                                                                     {
  722.                                                                                        set("\x01",eval("\x01") - 431);
  723.                                                                                        ┬º┬ºgoto(addr1081);
  724.                                                                                        ┬º┬ºpush("\x0f");
  725.                                                                                        ┬º┬ºpush(1);
  726.                                                                                     }
  727.                                                                                     if(eval("\x01") == 910)
  728.                                                                                     {
  729.                                                                                        set("\x01",eval("\x01") - 769);
  730.                                                                                        ┬º┬ºgoto(addr1081);
  731.                                                                                     }
  732.                                                                                     if(eval("\x01") == 811)
  733.                                                                                     {
  734.                                                                                        set("\x01",eval("\x01") - 574);
  735.                                                                                        if(!┬º┬ºpop())
  736.                                                                                        {
  737.                                                                                           addr1357:
  738.                                                                                           ┬º┬ºgoto(addr1081);
  739.                                                                                        }
  740.                                                                                        set("\x01",eval("\x01") + 244);
  741.                                                                                        ┬º┬ºgoto(addr1357);
  742.                                                                                     }
  743.                                                                                     if(eval("\x01") == 241)
  744.                                                                                     {
  745.                                                                                        set("\x01",eval("\x01") + 513);
  746.                                                                                        ┬º┬ºgoto(addr1081);
  747.                                                                                     }
  748.                                                                                     if(eval("\x01") == 323)
  749.                                                                                     {
  750.                                                                                        set("\x01",eval("\x01") + 277);
  751.                                                                                        var ┬º┬ºpop() = ┬º┬ºpop();
  752.                                                                                        ┬º┬ºgoto(addr1081);
  753.                                                                                     }
  754.                                                                                     if(eval("\x01") == 768)
  755.                                                                                     {
  756.                                                                                        set("\x01",eval("\x01") - 193);
  757.                                                                                        ┬º┬ºgoto(addr1081);
  758.                                                                                        ┬º┬ºpush(!┬º┬ºpop());
  759.                                                                                     }
  760.                                                                                     if(eval("\x01") == 612)
  761.                                                                                     {
  762.                                                                                        set("\x01",eval("\x01") - 101);
  763.                                                                                        hornsplaying = false;
  764.                                                                                        break loop0;
  765.                                                                                     }
  766.                                                                                     if(eval("\x01") == 511)
  767.                                                                                     {
  768.                                                                                        set("\x01",eval("\x01") - 511);
  769.                                                                                        break loop0;
  770.                                                                                     }
  771.                                                                                     break loop0;
  772.                                                                                  }
  773.                                                                                  set("\x01",eval("\x01") + 244);
  774.                                                                                  break loop0;
  775.                                                                               }
  776.                                                                               if(eval("\x01") == 528)
  777.                                                                               {
  778.                                                                                  set("\x01",eval("\x01") - 344);
  779.                                                                                  continue;
  780.                                                                               }
  781.                                                                               if(eval("\x01") == 304)
  782.                                                                               {
  783.                                                                                  set("\x01",eval("\x01") - 143);
  784.                                                                                  continue;
  785.                                                                               }
  786.                                                                               if(eval("\x01") != 567)
  787.                                                                               {
  788.                                                                                  if(eval("\x01") == 360)
  789.                                                                                  {
  790.                                                                                     set("\x01",eval("\x01") + 89);
  791.                                                                                     if(eval("∩┐╜/M∩┐╜∩┐╜")["c+┬╣"] != ┬º┬ºconstant(2))
  792.                                                                                     {
  793.                                                                                        eval("∩┐╜/M∩┐╜∩┐╜")[┬º┬ºconstant(3)]();
  794.                                                                                        eval("∩┐╜/M∩┐╜∩┐╜")[┬º┬ºconstant(4)](┬º┬ºconstant(2));
  795.                                                                                        eval("∩┐╜/M∩┐╜∩┐╜")["c+┬╣"] = ┬º┬ºconstant(2);
  796.                                                                                        eval("∩┐╜/M∩┐╜∩┐╜")[┬º┬ºconstant(5)] = 1;
  797.                                                                                     }
  798.                                                                                     break loop0;
  799.                                                                                  }
  800.                                                                                  if(eval("\x01") == 449)
  801.                                                                                  {
  802.                                                                                     set("\x01",eval("\x01") - 449);
  803.                                                                                     break loop0;
  804.                                                                                  }
  805.                                                                               }
  806.                                                                            }
  807.                                                                         }
  808.                                                                         set("\x01",eval("\x01") - 178);
  809.                                                                         if(┬º┬ºpop())
  810.                                                                         {
  811.                                                                            set("\x01",eval("\x01") + 216);
  812.                                                                         }
  813.                                                                         continue;
  814.                                                                         set("\x01",eval("\x01") + 688);
  815.                                                                      }
  816.                                                                      set("\x01",eval("\x01") + 13);
  817.                                                                      ┬º┬ºpush("\x0f");
  818.                                                                      continue;
  819.                                                                   }
  820.                                                                   set("\x01",eval("\x01") + 110);
  821.                                                                   if(┬º┬ºpop())
  822.                                                                   {
  823.                                                                      set("\x01",eval("\x01") - 207);
  824.                                                                   }
  825.                                                                   continue;
  826.                                                                }
  827.                                                                set("\x01",eval("\x01") - 362);
  828.                                                                ┬º┬ºpush(true);
  829.                                                                continue;
  830.                                                                ┬º┬ºpush(eval(┬º┬ºpop()));
  831.                                                             }
  832.                                                          }
  833.                                                          set("\x01",eval("\x01") - 306);
  834.                                                          break loop0;
  835.                                                       }
  836.                                                       if(eval("\x01") != 227)
  837.                                                       {
  838.                                                          if(eval("\x01") == 609)
  839.                                                          {
  840.                                                             break;
  841.                                                          }
  842.                                                          if(eval("\x01") != 228)
  843.                                                          {
  844.                                                             if(eval("\x01") == 771)
  845.                                                             {
  846.                                                                set("\x01",eval("\x01") - 321);
  847.                                                                _root.prevSnd.goracer = 5;
  848.                                                                _root.chkSnd.goracer = 3;
  849.                                                                _root.chkSnd.sfx.prevSndType(4);
  850.                                                                _root[┬º┬ºconstant(6)]();
  851.                                                                break loop0;
  852.                                                             }
  853.                                                             if(eval("\x01") == 450)
  854.                                                             {
  855.                                                                set("\x01",eval("\x01") - 450);
  856.                                                                break loop0;
  857.                                                             }
  858.                                                          }
  859.                                                          set("\x01",eval("\x01") - 8);
  860.                                                          if(┬º┬ºpop())
  861.                                                          {
  862.                                                             set("\x01",eval("\x01") + 551);
  863.                                                          }
  864.                                                       }
  865.                                                       set("\x01",eval("\x01") + 382);
  866.                                                       var ┬º┬ºpop() = ┬º┬ºpop();
  867.                                                    }
  868.                                                 }
  869.                                                 set("\x01",eval("\x01") - 232);
  870.                                                 continue;
  871.                                                 set("\x01",eval("\x01") - 442);
  872.                                              }
  873.                                              set("\x01",eval("\x01") - 25);
  874.                                              if(┬º┬ºpop())
  875.                                              {
  876.                                                 set("\x01",eval("\x01") + 111);
  877.                                              }
  878.                                           }
  879.                                           set("\x01",eval("\x01") - 665);
  880.                                           ┬º┬ºpush("\x0f");
  881.                                           ┬º┬ºpush(1);
  882.                                           continue;
  883.                                        }
  884.                                        set("\x01",eval("\x01") + 487);
  885.                                        continue;
  886.                                        continue;
  887.                                     }
  888.                                     set("\x01",eval("\x01") - 174);
  889.                                     ┬º┬ºpush(true);
  890.                                     continue;
  891.                                  }
  892.                                  set("\x01",eval("\x01") - 435);
  893.                                  ┬º┬ºpush(!┬º┬ºpop());
  894.                                  continue;
  895.                               }
  896.                               set("\x01",eval("\x01") + 555);
  897.                               continue;
  898.                            }
  899.                            set("\x01",eval("\x01") + 244);
  900.                            continue;
  901.                         }
  902.                         set("\x01",eval("\x01") - 102);
  903.                         continue;
  904.                      }
  905.                      set("\x01",eval("\x01") - 392);
  906.                      ┬º┬ºpush(true);
  907.                   }
  908.                   set("\x01",eval("\x01") - 408);
  909.                }
  910.                set("\x01",eval("\x01") - 640);
  911.                break loop0;
  912.             }
  913.             if(eval("\x01") == 843)
  914.             {
  915.                set("\x01",eval("\x01") + 83);
  916.                ┬º┬ºpush(!┬º┬ºpop());
  917.             }
  918.             else if(eval("\x01") == 347)
  919.             {
  920.                set("\x01",eval("\x01") + 279);
  921.                if(┬º┬ºpop())
  922.                {
  923.                   set("\x01",eval("\x01") - 429);
  924.                }
  925.             }
  926.             else
  927.             {
  928.                if(eval("\x01") == 626)
  929.                {
  930.                   set("\x01",eval("\x01") - 429);
  931.                   loop3:
  932.                   while(true)
  933.                   {
  934.                      set(┬º┬ºpop(),┬º┬ºpop());
  935.                      ┬º┬ºpush("\x0f");
  936.                      ┬º┬ºpush(1);
  937.                      while(true)
  938.                      {
  939.                         if(eval("\x01") != 142)
  940.                         {
  941.                            if(eval("\x01") != 963)
  942.                            {
  943.                               if(eval("\x01") != 585)
  944.                               {
  945.                                  if(eval("\x01") != 600)
  946.                                  {
  947.                                     if(eval("\x01") != 711)
  948.                                     {
  949.                                        if(eval("\x01") == 645)
  950.                                        {
  951.                                           break;
  952.                                        }
  953.                                        if(eval("\x01") == 107)
  954.                                        {
  955.                                           break loop3;
  956.                                        }
  957.                                        if(eval("\x01") != 619)
  958.                                        {
  959.                                           if(eval("\x01") == 980)
  960.                                           {
  961.                                              set("\x01",eval("\x01") - 627);
  962.                                              continue;
  963.                                           }
  964.                                           if(eval("\x01") == 353)
  965.                                           {
  966.                                              set("\x01",eval("\x01") + 474);
  967.                                              ┬º┬ºpush(true);
  968.                                              continue;
  969.                                           }
  970.                                           if(eval("\x01") == 248)
  971.                                           {
  972.                                              set("\x01",eval("\x01") - 115);
  973.                                              ┬º┬ºpush(eval(┬º┬ºpop()));
  974.                                              continue;
  975.                                           }
  976.                                           if(eval("\x01") == 827)
  977.                                           {
  978.                                              set("\x01",eval("\x01") + 172);
  979.                                              if(┬º┬ºpop())
  980.                                              {
  981.                                                 set("\x01",eval("\x01") - 970);
  982.                                              }
  983.                                              continue;
  984.                                           }
  985.                                           if(eval("\x01") != 29)
  986.                                           {
  987.                                              if(eval("\x01") == 999)
  988.                                              {
  989.                                                 set("\x01",eval("\x01") - 970);
  990.                                                 break loop0;
  991.                                              }
  992.                                              if(eval("\x01") != 133)
  993.                                              {
  994.                                                 if(eval("\x01") != 137)
  995.                                                 {
  996.                                                    if(eval("\x01") == 3)
  997.                                                    {
  998.                                                       set("\x01",eval("\x01") + 553);
  999.                                                       hornsplaying = false;
  1000.                                                       break loop0;
  1001.                                                    }
  1002.                                                    if(eval("\x01") == 556)
  1003.                                                    {
  1004.                                                       set("\x01",eval("\x01") - 556);
  1005.                                                       break loop0;
  1006.                                                    }
  1007.                                                 }
  1008.                                                 set("\x01",eval("\x01") - 134);
  1009.                                                 if(┬º┬ºpop())
  1010.                                                 {
  1011.                                                    set("\x01",eval("\x01") + 0);
  1012.                                                 }
  1013.                                              }
  1014.                                              set("\x01",eval("\x01") + 4);
  1015.                                              ┬º┬ºpush(!┬º┬ºpop());
  1016.                                           }
  1017.                                        }
  1018.                                        set("\x01",eval("\x01") - 266);
  1019.                                        continue;
  1020.                                        continue;
  1021.                                     }
  1022.                                     set("\x01",eval("\x01") - 126);
  1023.                                     var ┬º┬ºpop() = ┬º┬ºpop();
  1024.                                     continue;
  1025.                                     set("\x01",eval("\x01") + 616);
  1026.                                  }
  1027.                                  set("\x01",eval("\x01") - 493);
  1028.                                  if(┬º┬ºpop())
  1029.                                  {
  1030.                                     set("\x01",eval("\x01") + 873);
  1031.                                  }
  1032.                                  continue;
  1033.                               }
  1034.                               set("\x01",eval("\x01") - 337);
  1035.                               ┬º┬ºpush("\x0f");
  1036.                               continue;
  1037.                            }
  1038.                            set("\x01",eval("\x01") - 318);
  1039.                            continue;
  1040.                            continue;
  1041.                         }
  1042.                         set("\x01",eval("\x01") + 458);
  1043.                         ┬º┬ºpush(true);
  1044.                      }
  1045.                   }
  1046.                   set("\x01",eval("\x01") + 873);
  1047.                   break loop0;
  1048.                }
  1049.                if(eval("\x01") == 104)
  1050.                {
  1051.                   set("\x01",eval("\x01") + 662);
  1052.                   ┬º┬ºpush("\x0f");
  1053.                }
  1054.                else
  1055.                {
  1056.                   if(eval("\x01") != 933)
  1057.                   {
  1058.                      break;
  1059.                   }
  1060.                   set("\x01",eval("\x01") - 511);
  1061.                   ┬º┬ºpush("\x0f");
  1062.                   ┬º┬ºpush(1);
  1063.                }
  1064.             }
  1065.          }
  1066.       }
  1067.    }
  1068. }
  1069.